// 模块化
;(function (){
    // 构造函数
    function Promise(excutor){
        console.log( 'Promise构造函数...' );

        // this -> Promise的实例对象

        // 记录Promise对象的状态
        this.state = 'pending';

        // 记录Promise对象的结果
        this.result = undefined;

        // 缓存this指向
        var _this = this;
        // var that = this;
        // var self = this;

        // resolve函数，将Promise对象的状态从pending改变为fulfilled
        function resolve(resolveValue){
            console.log( 'resolve函数...' );

            // 判断当前Promise对象的状态
            if (_this.state !== 'pending') {
                // Promise对象的状态已改变，结束执行
                return;
            }

            // 记录状态
            _this.state = 'fulfilled';

            // 记录结果
            _this.result = resolveValue;
        };

        // reject函数，将Promise对象的状态从pending改变为rejected
        function reject(rejectValue){
            console.log( 'reject函数...' );

            // 判断当前Promise对象的状态
            if (_this.state !== 'pending') {
                // Promise对象的状态已改变，结束执行
                return;
            }

            // 记录状态
            _this.state = 'rejected';

            // 记录结果
            _this.result = rejectValue;
        }

        // excutor函数，同步执行
        try {
            // 捕获excutor函数内部的错误或抛出的值
            excutor(resolve,reject);
        } catch (error) {
            // 将Promise对象的状态从pending改变为rejected
            reject(error);
        }
    }

    // then方法（重点难点）
    Promise.prototype.then = function (){
        console.log( 'then方法...' );
    }

    // catch方法
    Promise.prototype.catch = function (){
        console.log( 'catch方法...' );
    }

    // all静态方法
    Promise.all = function (){
        console.log( 'all静态方法...' );
    }

    // race静态方法
    Promise.race = function (){
        console.log( 'race静态方法...' );
    }

    // 如何在自执行函数外部访问Promise函数？
    // return Promise; // 外部不能访问
    window.Promise = Promise;
})();
